home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / libgutil / README < prev    next >
Text File  |  1994-08-01  |  48KB  |  1,711 lines
  1.  
  2.             libgutil.a:  Using the graphics utilities library
  3.  
  4.  
  5.         The following list represents the modules within libgutil.a 
  6.         (following the list are documented notes for selected modules.
  7.          At the present time, those included have a `+' sign to the 
  8.          left of their entry on the following list.)
  9.  
  10.  
  11.   abekas.c:    support for digital video
  12.   acc.c:        software accumulation buffer implementation
  13.   arg.c:        arg_parse:  command-line argument parser
  14.   bitmap.c:    support for the allocation, manipulation, and display of bitmaps
  15.   bm.c:         simple support for bitmap reading
  16.   brect.c:    support for drawing beveled rectangles
  17.   brush.c:      draw geometric brushes for impression
  18.   bufpool.c:    support for allocation/freeing of a pool of buffers
  19.   charfill.c:    creates and draws anti-aliased bitmaps of an outline font
  20.   checkchar.c:  test a character outline for self intersections
  21.   cmap.c:       color map support
  22. + cmyk.c:    functions to support CMYK representations
  23. + colormod.c:    define some transforms between different color models
  24.   corprt3.c:    contains color correction support for generic corimg3 & sproof3 
  25.   corprt4.c:    color correction technique for multi angle screening w/4 colors
  26. + dispimg.c:    general package for the display of images on all machines
  27.   dit.c:        dither pixels into 1 bit deep bits
  28.   expr.c:       expression evaluator - converts ascii string to floating point
  29.   fastimg.c:    faster copies between long pixel data and image files
  30.   fastobj.c:    support for spin format objects (obsoleted by sgiobj files)
  31.   fax.c:        support for writing fax files
  32.   fft.c:        simple 2-D fft support
  33.   file.c:    miscellaneous support for files
  34.   filepath.c:   pathname convenience package
  35.   fit2d.c:      fit a plane to a 2D scalar function
  36.   follow.c:    routines for manipulation of sgo format objects  
  37.   fzoom.c:      mag/mi -nify an array of longs using impulse zoom w/no filtering
  38.   gamma.c:    gamma correction support for reading and writing c-map entries
  39.   gendit.c:    general support for dithering;  slow, but correct
  40.   geom.c:       a software geometry package for computer graphics
  41.   getapixel.c:    read a pixel value from a specific screen location
  42.   getfile.c:    file manipulation support
  43.   getset.c:    get and set values stored in ~/.gamma
  44.   gif.c:        GIF img interface w/Lempel-Zim compression based on "compress"
  45. + glshade.c:    simple support for describing materials and light sources
  46.   glshapes.c:   basic euclidean shapes routines implemented in gl
  47. + glstuff.c:    graphics library support functions
  48.   handline.c:   human line code implementation
  49.   hideline.c:   a hidden line algotithm
  50.   hipass.c:    hi pass filter rows of an image using a 3x3 kernel
  51. + hist.c:    support for histogram creation and display
  52.   homo2.c:      homogeneous mapping in 2 dimensions
  53.   hypcurve.c:    create hyperbolic and power curves for correcting printers
  54. + imgread.c:    read an image into an array of longs
  55.   invgamma.c:   invert arbitrary gamma look up tables
  56.   invmap.c:     make and use inverse maps for dithering
  57.   izoom.c:    magnify or minify a picture with or without filtering
  58.   lut.c:    create and apply look up tables
  59.   manifesto.c:  the manifesto of the futurist programmers
  60. + matrix.c:    utilities for working with matrices
  61. + misc.c:    miscellaneous system-based functions that do not rely on the gl
  62. + miscgl.c:    miscellaneous functions that rely on the gl
  63.   movie.c:      file support for movie files
  64.   mysystem.c:   alternative implementation of system
  65.   objdraw.c:    some utilities for drawing geometric objects
  66.   objfnt.c:    support for spline and polygonal fonts
  67.   objlib.c:    utilities for reading and writing geometric objects
  68.   objop.c:      some operations on geometric objects
  69.   path.c:       supports creation of PostScript stroked, filled, & beveled paths
  70. + percent.c:    indicate percent done on time consuming operations
  71.   perlin.c:     noise and dnoise routines
  72.   polyscan.c:   polygon scanline rendering for characters
  73.   propdit.c:    general propagation dither support
  74. + psimg.c:    convert image data into b/w or color PostScript
  75.   pstri.c:    postscript support for drawing lines, and shaded triangles
  76.   qquant.c:     quick quant based on heckbert's median cut algoirthm 
  77.   quant.c:      quant - general median cut algorithm based on heckbert's m.c.a.
  78.   rand.c:    generate high quality randow numbers (employs Berkeley random)
  79. + rct.c:    management of rectangles
  80.   rctgl.c:      more GL code for management of rectangles
  81.   rendchar.c:   convert polygonal outlines into bitmaps
  82.   render.c:    employing the GL to generate high resolution rendered images
  83.   resource.c:   make it very very easy to use cursors, patterns, and bitmaps
  84.   rgn.c:    managment of regions (an area described by a list of rectangles)
  85. + row.c:    support for operations on image rows
  86.   rpc.c:        put different things to a stream: floats,ints,strings & newlines
  87.   sample.c:     support for managing sample sets
  88.   setscreen.c:    PostScript style halftoning stuff
  89.   sgiobj.c:    utilities for reading and writing sgiobj format geometry
  90.   sgiobjgl.c:    GL support for drawing sgiobj format geometry
  91.   shade.c:      support for describing materials and light sources by text files
  92.   shadow.c:    make it easy to select a halftone gray pattern for shadows
  93.   simptex.c:    stapuft comatible texture mapping support
  94.   sprender.c:   generic gl rendering stuff
  95.   sptexture.c:  stapuft comatible texture mapping support
  96.   stream.c:    autotracing support:  converts an image into lines
  97.   subpix.c:     subpixel positioned trapazoid and line prims
  98.   textmap.c:    use texture mapping to draw text
  99.   texture.c:    support for software texture maps 
  100.   tl.c:         tri list file io support
  101.   tmeshobj.c:    support to convert an sgi obj into triangle meshes
  102.   tomesh.c:    convert independent triangles to large triangle meshes
  103. + track.c:    simple track ball interface
  104. + turtle.c:    a simple implementation of turtle graphics
  105.   type1rd.c:    read an Adobe type 1 font into objfnt data structure
  106.   unmesh.c:    convert tmesh calls into triangles
  107. + vcolor.c:    provide virtual rgb and grey scale support
  108.   vcool.c:      flag "bad" rgb pixel vals for encoded NTSC or PAL colour signal
  109. + vect.c:    various functions to support operations on vectors
  110.   vidcomp.c:    video compression support
  111.  
  112.  
  113.  
  114.  
  115. =============================================================================
  116.  
  117.       N O T E S    O N    M O D U L E S    I N    L I B G U T I L . A 
  118.  
  119. =============================================================================
  120. cmyk.c:  functions to support CMYK representations
  121. #include "math.h"
  122. #include "stdio.h"
  123. #include "image.h"
  124. #include "lum.h"
  125.  
  126. rgb_to_cmyk(register int r, g, b;  int *c, *m, *y, *k; short cortab[256])
  127.  
  128.      Convert from rgb to cmyk color space.  This implements grey component
  129.      replacement.
  130.  
  131.       Inputs:   r intensity 0 to 255
  132.                 g intensity 0 to 255
  133.                 b intensity 0 to 255
  134.  
  135.       Outputs:  c coverage 0 to 255
  136.                 m coverage 0 to 255
  137.                 y coverage 0 to 255
  138.                 k coverage 0 to 255
  139.  
  140.       An input value of rgb=[255,255,255] represents white.  When this is
  141.       transformed to cmyk, we get cmyk=[0,0,0,0] which represents zero
  142.       coverage.
  143.  
  144.       An input value of rgb=[128,128,128] represents 50 percent grey.  When
  145.       this is transformed to cmyk, we get cmyk=[0,0,0,127] which represents
  146.       zero coverage by cmy, and 50 percent coverage by black.
  147.  
  148.  
  149. frgb_to_cmyk(register float r, g, b;  float *c, *m, *y, *k)
  150.  
  151.       Convert from rgb to cmyk.  This implements grey component replacement.
  152.  
  153.       Inputs:   r intensity 0 to 1.0
  154.                 g intensity 0 to 1.0
  155.                 b intensity 0 to 1.0
  156.  
  157.       Outputs:  c coverage 0 to 255
  158.                 m coverage 0 to 255
  159.                 y coverage 0 to 255
  160.                 k coverage 0 to 255
  161.  
  162.       An input value of rgb=[1.0,1.0,1.0] represents white.  When this is
  163.       transformed to cmyk, we get cmyk=[0,0,0,0] which represents zero
  164.       coverage.
  165.  
  166.       An input value of rgb=[0.5,0.5,0.5] represents 50 percent grey.  When
  167.       this is transformed to cmyk, we get cmyk=[0,0,0,127] which represents
  168.       zero coverage by cmy, and 50 percent coverage by black.
  169.  
  170.  
  171.  
  172. =============================================================================
  173. colormod.c:  define some transforms between different color models.
  174. #include "stdio.h"
  175. #include <math.h>
  176. #include "port.h"
  177.  
  178. Convert FROM various formats TO rgb:
  179.  
  180.   irgb_to_rgb(int ir, ig, ib;  float *r, *g, *b)
  181.  
  182.     convert an integer rgb triplet into floating point.  The integer
  183.     rgb values are in the range 0..255.  The returned values are in 
  184.     the range 0.0..1.0.
  185.  
  186.  
  187.   cmy_to_rgb(float c, m, y;  float *r, *g, *b)
  188.  
  189.     convert cyan, magenta, yellow floating point values to rgb floating point
  190.     values.  
  191.  
  192.  
  193.   hls_to_rgb(float h, l, s;  float *r, *g, *b)
  194.  
  195.     convert hue, lightness, saturation floating point values to rgb floating 
  196.     point values.
  197.  
  198.  
  199.   hsv_to_rgb(float h, s, v;  float *r, *g, *b)
  200.  
  201.     convert hue, saturation, value floating point values to rgb floating 
  202.     point values.
  203.  
  204.  
  205.   hsb_to_rgb(float h, s, b;  float *r, *g, *b)
  206.  
  207.     convert hue, saturation, brightness floating point values to rgb floating 
  208.     point values.
  209.  
  210.  
  211.   yiq_to_rgb(float y, i, q;  float *r, *g, *b)
  212.  
  213.     convert NTSC YIQ floating point values to rgb floating 
  214.     point values.
  215.  
  216.  
  217.   rgb_to_rgb(float fr, fg, fb, *tr, *tg, *tb)
  218.  
  219.     copy from rgb floating point values to rgb floating point values.
  220.  
  221.  
  222.  
  223. Convert TO various formats FROM rgb:
  224.  
  225.   rgb_to_cmy(float r, g, b;  float *c, *m, *y)
  226.  
  227.     convert from rgb floating point values to cyan, magenta, yellow floating
  228.     point values.
  229.  
  230.  
  231.   rgb_to_irgb(float r, g, b;  float *ir, *ig, *ib)
  232.  
  233.     convert from normalized rgb floating point values to rgb integer values
  234.     in the range 0...255.
  235.  
  236.  
  237.   rgb_to_hls(float r, g, b;  float *h, *l, *s)
  238.  
  239.     convert from rgb floating point values to hue, lightness, saturation
  240.     floating point values.
  241.  
  242.  
  243.   rgb_to_hsv(float r, g, b;  float *lh, *ls, *lv)
  244.  
  245.     convert from rgb floating point values to hue, saturation, value floating
  246.     point values.
  247.  
  248.  
  249.   rgb_to_hsb(float r, g, b;  float *lh, *ls, *lb)
  250.  
  251.     convert from rgb floating point values to hue, saturation, brightness
  252.     floating point values.
  253.  
  254.  
  255.   rgb_to_yiq(float r, g, b;  float *y, *i, *q)
  256.  
  257.     convert from rgb floating point values to NTSC YIQ values.
  258.  
  259.   rgbcomplement(float r, g, b, *cr, *cg, *cb)
  260.  
  261.     this complements the color specified by r, g, and b and 
  262.     returns this rgb color in cr,cg,cb.  The complement color
  263.     will have the same saturation and value as the input 
  264.     color, but the hue is rotated 180 degrees.
  265.  
  266.  
  267. The following four functions allow you to select a preferred color system
  268. using a call like setcolorsys(COLORSYS_HSV).  After this is done, 
  269. fromrgb(float r,g,b,*s1,*s2,*s3) converts to that color space and 
  270. torgb(float s1,s2,s3,*r,*g,*b) converts from that color space to rgb.
  271.  
  272.   setcolorsys(int sys)
  273.  
  274.     setcolorsys defines what the current color system being used by the
  275.     TO/FROM format converter.  Currently there are five possibilities:
  276.  
  277.      COLORSYS_RGB rgb to rgb (and back)
  278.      COLORSYS_CMY cmy to rgb     "
  279.      COLORSYS_HSV hsv to rgb     "
  280.      COLORSYS_HLS hls to rgb     "
  281.      COLORSYS_YIQ yiq to rgb     "
  282.  
  283.  
  284.   getcolorsys(int sys)
  285.  
  286.     returns the current color system being employed by the TO/FROM converters.
  287.  
  288.  
  289.   torgb(float r, g, b;  float *tr, *tg, *tb)
  290.  
  291.     converts from the current color space to rgb space.
  292.  
  293.  
  294.   fromrgb(float r, g, b;  float *tr, *tg, *tb)
  295.  
  296.     converts from rgb space to the current color space.
  297.  
  298.  
  299.  
  300. =============================================================================
  301. dispimg.c:  General package for the display of images on all machines.
  302. #include "gl.h"
  303. #include "get.h"
  304. #include "dispimg.h"
  305. #include "image.h"
  306. #include "gfxmach.h"
  307.  
  308.       This package deals with the problems of dithering RGB images onto the 
  309.       screens of all IRISes from the very low end to the high end.  This 
  310.       is NOT what you need if you want to display iris images on a machine 
  311.       with RGBmode().  Take a look at imgread.c and study longimagedata as
  312.       a way of doing the manipulation of IRIS 24-bit RGB images into 
  313.       dithered 8-bit colormap images.
  314.       
  315.  
  316.   imagetype(IMAGE *image)
  317.  
  318.     return one of three kinds of possible images:  
  319.         RGBIMG:     RGB (24-bit deep) image
  320.         SCREENIMG:  a colormap (<= 12-bits deep) image 
  321.         BWIMG:      1 channel (8-bits of grayscale) image
  322.     
  323.  
  324.   drawimage(DISPIMAGE *di;  int xorg, yorg)
  325.  
  326.     does the actual drawing of the image to the GL window.  The correct
  327.     displaymode/machine type has already been determined and is used here
  328.     for proper pixel writing.  xorg and yorg are viewport relative.
  329.  
  330.  
  331.   DISPIMAGE *makedisprgn(IMAGE *image;  unsigned int x1, x2, y1, y2;
  332.                          int show, xorg, yorg)
  333.  
  334.     make the display region that can later be used by drawimage. 
  335.         *image           the image we wish to display.
  336.         x1, x2, y1, y2   the region inside the image itself that we wish
  337.                          to display (image coordinate space).
  338.         show             flag indicates whether to show the image as we
  339.                          are making this display region (TRUE) or not (FALSE).
  340.         xorg, yorg       specifies where to display the area of the image
  341.                          indicated by (x1,x2,y1,y2) above relative to the
  342.                          current viewport of our present GL window.
  343.  
  344.  
  345.        
  346. =============================================================================
  347. glshade.c:  Simple support for describing materials and light sources.
  348. #include "stdio.h"
  349. #include "gl.h"
  350.  
  351.  This makes it easy for people without PHD's in GL to actually shade surfaces.
  352.  
  353.  
  354.   Here is the structure of a typical program:
  355.  
  356.           main()
  357.           {
  358.               winopen("shade");
  359.               RGBmode();
  360.               doublebuffer();
  361.               gconfig();
  362.               winopen("blat");
  363.               matrixinit();               you must use two matrix model
  364.               .
  365.               .
  366.               perspective(  . . . . );
  367.               shadeinit();                init shading after perspective
  368.               .
  369.               .
  370.               while(1)
  371.                   cpack(0x00404060);      clear the screen
  372.                   clear();
  373.                   zclear();
  374.                   .
  375.                   .
  376.                   shadeon();                  turn lighting on
  377.                   setdiffuse(1.0,0.0,0.0);    make the diffuse color red
  378.                   drawobjwithnormals();       draw the object
  379.                   shadeoff();                 turn lighting off
  380.                   .
  381.                   .
  382.                   swapbuffers();          swap buffers
  383.               }
  384.           }
  385.  
  386.  
  387.  
  388.   matrixinit()
  389.  
  390.     initialize the lighting matrix by entering MVIEWING mode and explicitly
  391.     loading the identity matrix on the lighting matrix stack.
  392.  
  393.  
  394.   shadeinit()
  395.  
  396.     initialize the lighting matrix by entering MVIEWING mode and explicitly
  397.     loading the identity matrix on the lighting matrix stack.
  398.  
  399.  
  400.   shadeinit()
  401.  
  402.     initialize a set of default materials and lights, and bind lighting to
  403.     MODEL 0
  404.  
  405.  
  406.   shadeon()
  407.  
  408.     bind lighting to MODEL 1.
  409.  
  410.  
  411.   shadeoff()
  412.  
  413.     bind lighting to MODEL 0.
  414.  
  415.  
  416.   setdiffuse(float r, g, b)
  417.  
  418.     set the lighting model color to diffuse with the rgb floating point
  419.     triplet passed in.
  420.  
  421.  
  422.   setspecular(float r, g, b)
  423.  
  424.     set the lighting model color to specular with the rgb floating point
  425.     triplet passed in.
  426.  
  427.  
  428.   setshininess(float s)
  429.  
  430.     set the lighting model shininess value to s and then define Material
  431.     1 with that shininess value.
  432.  
  433.  
  434.  
  435. =============================================================================
  436. glstuff.c:  graphics library support functions.
  437. #include "stdio.h"
  438. #include "math.h"
  439. #include "gl.h"
  440. #include "device.h"
  441. #include "port.h"
  442. #include "gfxmach.h"
  443.  
  444.  
  445.   savewindow(char *name)
  446.     
  447.     save the current gl window's contents into an image file
  448.  
  449.     savewindow creates an image from the contents of the 
  450.     current GL window.  The name of the image is specified by
  451.     name.
  452.  
  453.  
  454.   printwindow()
  455.  
  456.     save the current gl window's contents and send it to the printer.
  457.     This program executes a shell script called "printimage" to actually
  458.     print the image file. printimage should be placed in /usr/sbin
  459.     or somewhere in the default path.  This small shell script
  460.     should look something like:
  461.  
  462.         lp -dseiko < $1
  463.  
  464.     if you have a seiko printer installed.
  465.  
  466.  
  467.   gfxmachine()
  468.  
  469.     determine which kind of IRIS 4D machine this is.  This function 
  470.     returns one of the values defined in the include file "gfxmach.h".  
  471.     The possible return values are:
  472.  
  473.     constant      numeric value                 meaning
  474.     ----------------------------------------------------------------------
  475.      MACH3D             0           2000 and 3000 machines 
  476.      MACH4D             1           Mips processor with first gen graphics 
  477.      MACH4DGT           2           Mips processor with high perf graphics
  478.      MACH4DPI           3           Personal IRIS
  479.      MACH4D8            4           Mips machine with 8 bitplanes 
  480.      MACH4DVGX          5           VGX machine
  481.  
  482.     NOTE:  MACH3D is being phased out of libgutil but is not completely
  483.            removed at this time.
  484.  
  485.  
  486.   smartsetdepth()
  487.  
  488.     call lsetdepth with the maximum values for the current graphics
  489.     hardware.  This call the function fsetdepth(float near, far)
  490.     described below with the arguments 0.0 and 1.0.  This controls
  491.     the way that geometry z values map into hardware Z values for 
  492.     zbuffering and depth cueing.
  493.  
  494.  
  495.   fsetdepth(float near;  float far)
  496.  
  497.     device independent way of setting lsetdepth.  The values near and 
  498.     far should be in the range 0.0 to 1.0.  0.0 will map into the
  499.     smallest legal lsetdepth value, while 1.0 will map into 
  500.     the largest.  This function actually uses zviewport below
  501.     to call lsetdepth.
  502.  
  503.     
  504.   zviewport(long near;  long far)
  505.  
  506.     this simply calls lsetdepth with the given values, and save
  507.     local copies, so that getzviewport may be used by an application
  508.     to read the current lsetdepth values.
  509.  
  510.  
  511.   getzviewport(long *lnear; long *lfar)
  512.  
  513.     returns the current lsetdepth values from the last call to
  514.     zviewport.
  515.  
  516.  
  517.   drawmeshimage(unsigned long *imgdata;  int xsize;  int ysize)
  518.  
  519.     draws an image as a triangle mesh.  This is useful for creating
  520.     background images on machines that may not support texture mapping.
  521.     The pointer imgdata points to an array of longs that is xsize pixels 
  522.     wide and ysize pixels high.  The image will cover the same area as 
  523.     a rectangle drawn with rectf(0.0,0.0,1.0,1.0).
  524.  
  525.  
  526. /*
  527.  *   meshimg.c:
  528.  *
  529.  *       using longimagedata() (see imgread.c) to convert image file 
  530.  *    data into lrectwrite format, we then implement drawmeshimage() 
  531.  *    to demonstrate drawing an image as a triangle mesh.  
  532.  *    NOTE:  this program works optimally with small images.
  533.  *
  534.  *                      Paul Haeberli and dave rat - 1991
  535.  */
  536. #include <stdio.h>
  537. #include <gl/gl.h>
  538. #include <gl/device.h>
  539.  
  540. int xsize, ysize;
  541. long *imgdat;
  542.  
  543. main(argc,argv)
  544. int argc;
  545. char **argv;
  546. {
  547.     short val;
  548.  
  549.     if(argc<2) {
  550.        fprintf(stderr,"usage: meshimg: inimage.rgb\n");
  551.     exit(1);
  552.     }
  553.     winopen("meshimg");
  554.     RGBmode();
  555.     gconfig();
  556.  
  557.     sizeofimage(argv[1],&xsize,&ysize);
  558.     printf("the size of the image is %d by %d\n",xsize,ysize);
  559.     imgdat = (long *)longimagedata(argv[1]);
  560.     drawit();
  561.     while(1) {
  562.     switch(qread(&val)) {
  563.         case REDRAW:
  564.         drawit();
  565.         break;
  566.     }
  567.  
  568.     }
  569. }
  570.  
  571. drawit()
  572. {
  573.     reshapeviewport();
  574.     ortho2(0.0,1.0,0.0,1.0);
  575.     drawmeshimage(imgdat,xsize,ysize);
  576. }
  577.  
  578.  
  579.  
  580.  
  581.  
  582.  
  583. =============================================================================
  584. hist.c:  Support for histogram creation and display.
  585. #include "hist.h"
  586. #include "gl.h"
  587.  
  588.   histogram *newhist(int min, max, nbuckets)
  589.  
  590.     allocate a new histogram structure, assign the appropriate elements
  591.     passed in, and initialize to zero the nbuckets bucket list.
  592.  
  593.  
  594.   freehist(histogram *hist)
  595.  
  596.     de-allocate the memory of structure hist.
  597.  
  598.  
  599.   clearhist(histogram *hist)
  600.  
  601.     re-initialize all the buckets of the hist structure to zero.
  602.  
  603.  
  604.   addtohist(histogram *hist;  unsigned short sptr;  int n)
  605.  
  606.     adds an array of integer values to the histogram.  This is how
  607.     information is accumulated in a histogram.
  608.  
  609.  
  610.   showhist(histogram *hist)
  611.  
  612.     draws the histogram into the current viewport.
  613.  
  614.  
  615.  
  616.  
  617. =============================================================================
  618. imgread.c:  Read an image into an array of longs.
  619. #include "stdio.h"
  620. #include "image.h"
  621.  
  622.   sizeofimage(char *name, int *xsize, int *ysize)
  623.  
  624.     opens an image file and returns in xsize and ysize the width
  625.     and height of the image in pixels.
  626.  
  627.  
  628.   long *longimagedata(char *name)
  629.  
  630.     convert image file data into lrectwrite format.
  631.  
  632.     longimagedata opens the named image file, and returns a pointer to 
  633.     an array of longs containing the pixel values of that image.  This 
  634.     function can read black and white, rgb and rgba images.  These images 
  635.     contain 1, 3, or 4 channels respectively.  longimagedata is useful 
  636.     for converting image file pixel data into a format that can 
  637.     be used with lrectwrite(3G) and drawmeshimage described above.
  638.     (see the meshimg.c example prog (above) as well as the rectimg example
  639.     (below) for implementations of this tremendously useful function.)
  640.  
  641.  
  642.   short *shortimagedata(char *name)
  643.  
  644.     convert color index image file data into rectwrite format.
  645.  
  646.     shortimagedata opens the named image file, and returns a pointer to 
  647.     an array of shorts containing the pixel values of that image.  This 
  648.     function can read an image file that contains color index pixels.
  649.     shortimagedata is useful for converting color index pixel image file
  650.     data into a format that can be used with rectwrite(3G).
  651.  
  652.  
  653.   char *charimagedata(char *name)
  654.  
  655.     convert image pixel data into character data.
  656.  
  657.     charimagedata opens the named image file, and returns a pointer to 
  658.     an array of chars containing the pixel values of that image.  This 
  659.     function can read black and white image files onto an array of chars.
  660.     You'll have to figure out what this is good for.
  661.  
  662.  
  663. /*
  664.  *    rectimg - 
  665.  *        Display a color or black and white image on the IRIS making
  666.  *      use of the extra*heem*ly swank longimagedata() function.  Simple
  667.  *    version for demo use.  This will only work on machines that support
  668.  *    RGB mode.
  669.  *                     Paul Haeberli - 1988
  670.  *
  671.  */
  672. #include "gl.h"
  673. #include "device.h"
  674. #include "image.h"
  675.  
  676. unsigned long *longimagedata();
  677.  
  678. IMAGE *image;
  679. int xsize, ysize, zsize;
  680. unsigned long *lptr;
  681. int xscreensize;
  682. int yscreensize;
  683.  
  684. main(argc,argv)
  685. int argc;
  686. char **argv;
  687. {
  688.     short val;
  689.  
  690.     if( argc<2 ) {
  691.     printf("usage: rectimg inimage\n");
  692.     exit(1);
  693.     } 
  694.     xscreensize = getgdesc(GD_XPMAX);
  695.     yscreensize = getgdesc(GD_YPMAX);
  696.     sizeofimage(argv[1],&xsize,&ysize);
  697.     printf("size is %d %d\n",xsize,ysize);
  698.     if( xsize > xscreensize || ysize > yscreensize) {
  699.     printf("rectimg: input image is too big %d %d",xsize,ysize);
  700.     exit(1);
  701.     }
  702.     prefsize(xsize,ysize);
  703.     winopen("rectimg");
  704.     RGBmode();
  705.     gconfig();
  706.     lptr = (unsigned long *)longimagedata(argv[1]);
  707.     drawit();
  708.     while(1) {
  709.     switch(qread(&val)) {
  710.         case REDRAW:
  711.         drawit();
  712.         break;
  713.     }
  714.     }
  715. }
  716.  
  717. drawit()
  718. {
  719.     reshapeviewport();
  720.     lrectwrite(0,0,xsize-1,ysize-1,lptr);
  721. }
  722.  
  723.  
  724.  
  725.  
  726.  
  727. =============================================================================
  728. matrix.c:  utilities for working with matrices.
  729. #include "stdio.h"
  730.  
  731.   identmat(float *matrix)
  732.  
  733.     initialize the 4x4 matrix passed in by its address to the identity matrix.
  734.  
  735.  
  736.   xformpnt(float *matrix;  float x, y, z;  float *tx, *ty, *tz)
  737.  
  738.     transform the point (x,y,z) by matrix, and return the transformed point
  739.     in tx, ty and tz.
  740.  
  741.  
  742.   copymat(float *mat1;  float *mat2)
  743.  
  744.     copy the 4x4 mat1 matrix values into mat2.
  745.  
  746.  
  747.   printmat(float mat[4][4])
  748.  
  749.     print out the 4x4 matrix mat.
  750.  
  751.  
  752.   transpose(float from[4][4];  float to[4][4])
  753.  
  754.     transpose the values in the 4x4 from matrix into the to matrix.
  755.  
  756.  
  757.   invertmat(float from[4][4];  float to[4][4])
  758.  
  759.     invert the values in the 4x4 from matrix into the to matrix.
  760.  
  761.  
  762.   matrixmult(float a[4][4], b[4][4], c[4][4])
  763.  
  764.     multiply the 4x4 matrices a and b, and save the result into matrix c.
  765.  
  766.  
  767.  
  768.  
  769. =============================================================================
  770. misc.c:  Miscellaneous system-based functions that don't not rely on the gl.
  771. #include "stdio.h"
  772. #include <sys/types.h>
  773. #include <sys/times.h>
  774. #include <sys/param.h>
  775.  
  776.   strtolower(char *str)
  777.  
  778.     convert the string, str, to lowercase.  if there are no uppercase 
  779.     characters str will be unchanged.  if for any character within the 
  780.     string, there is no corresponding lowercase character, that character
  781.     will remain unchanged.
  782.  
  783.  
  784.   ctos(unsigned char *cptr;  unsigned short *sptr, int n)
  785.  
  786.   convert a character string into its integer equivalent.
  787.  
  788.     convert the contents of the character string cprt into the equivalent
  789.     short integer representation and store the result in sptr.  ctos takes
  790.     one byte at a time from cptr, and assigns each bit into the same bit 
  791.     location in sprt.
  792.  
  793.     
  794.   stoc(unsigned short *sptr, unsigned char *cptr, int n)
  795.  
  796.     convert an integer into its character string equivalent.
  797.  
  798.     convert the contents of the short integer sptr into the equivalent
  799.     character string representation and store the result in cptr.  stoc
  800.     takes one byte at a time from sptr, and assigns each bit into the same
  801.     bit location in cptr.
  802.  
  803.  
  804.   delay(float secs)
  805.  
  806.     delay will suspend the current process for secs*CLK_TCK clock ticks.  if
  807.     secs is less than zero, nothing happens.  the length of a clock tick, 
  808.     CLK_TCK, is defined in the <limits.h> include file.
  809.  
  810.  
  811.   float uptime()
  812.  
  813.     uptime returns the floating point value of the elapsed real time, in
  814.     clock ticks per second, from system startup time.
  815.  
  816.  
  817.   cleartime()
  818.  
  819.     reset the current "beginning time" marker for a begin/end time 
  820.     measurement.
  821.  
  822.  
  823.   float gettime()
  824.  
  825.     gettime returns the elapsed time, represented as a floating point value,
  826.     from the last time gettime was called.  call cleartime() to reset the 
  827.     beginning moment of "elapsed time".
  828.  
  829.  
  830.   timefunc(int (*f)();  int n)
  831.  
  832.     get elapsed time for function f being called n times.
  833.  
  834.     timefunc takes the function pointed to by f and invokes it n times.  it
  835.     then divides the elapsed time taken to loop n times by n and prints the
  836.     number of seconds taken per call to stderr.
  837.  
  838.  
  839.   tpercentfile(FILE *f)
  840.  
  841.     specify an output file for tpercentdone to print its dots to.
  842.  
  843.  
  844.   tpercentdone(float p)
  845.  
  846.     a textual percent done visual cue routine.  
  847.     
  848.     print out a row of dots real-time showing the percent of the current
  849.     job that is completed.  tpercentdone prints out "......"
  850.  
  851.  
  852.  
  853.  
  854. =============================================================================
  855. miscgl.c:  Miscellaneous functions that rely on the gl.
  856. #include "values.h"
  857. #include "math.h"
  858. #include "stdio.h"
  859. #include "gl.h"
  860. #include "device.h"
  861.  
  862.   drawfunc(int (*f)())
  863.  
  864.     draw the function in an infinite loop waiting upon REDRAW events.
  865.  
  866.     drawfunc takes the function pointed to by f, explicitly calls it once,
  867.     and then goes into an infinite loop where it blocks waiting for REDRAW
  868.     events which then cause it to reinvoke the drawing function.
  869.  
  870.  
  871.   qmouse()
  872.  
  873.     queue the MOUSEX, MOUSEY, LEFT, RIGHT and MIDDLE -MOUSE buttons.
  874.  
  875.  
  876.   getmousex()
  877.  
  878.     get the window-relative MOUSEX location.
  879.  
  880.     getmousex returns the value of MOUSEX relative to the GL window's lower
  881.     left origin it is invoked within.  
  882.  
  883.  
  884.   getmousey()
  885.  
  886.     get the window-relative MOUSEY location.
  887.  
  888.     getmousey returns the value of MOUSEY relative to the GL window's lower
  889.     left origin it is invoked within.  
  890.  
  891.  
  892.   float fgetmousex()
  893.  
  894.     get the normalized window-relative MOUSEX location.
  895.  
  896.     fgetmousex returns the normalized floating point value of MOUSEX relative 
  897.     to the GL window's lower left origin it is invoked within.  
  898.  
  899.  
  900.   float fgetmousey()
  901.  
  902.     get the normalized window-relative MOUSEY location.
  903.  
  904.     fgetmousey returns the normalized floating point value of MOUSEY relative 
  905.     to the GL window's lower left origin it is invoked within.  
  906.  
  907.  
  908.   printsize()
  909.  
  910.     print the x/y size of the current window.
  911.  
  912.     print the integer values xsize and ysize of the current GL window to
  913.     stdout.
  914.  
  915.  
  916.   printorigin()
  917.  
  918.     print the x/y screen origin of the current window.
  919.  
  920.     print the absolute x/y screen coordinates of the origin of the current
  921.     GL window to stdout.
  922.  
  923.  
  924.   redraw(int (*f)()) 
  925.  
  926.     test for REDRAW in the queue and if so, call the function pointed to by f.
  927.  
  928.     test for a REDRAW token in the event queue, and, if present, call the 
  929.     optionally supplied user function as well reshaping the viewport based
  930.     on the new size.  if no user function is supplied, nothing happens
  931.     after the viewport is reshaped.
  932.  
  933.     
  934.   subviewport(long left, right, bottom, top)
  935.  
  936.     create a viewport of size/location {left, right, bottom, top} within
  937.     the entire graphics console (XMAXSCREEN by YMAXSCREEN size).
  938.  
  939.  
  940.   subport(float left, right, bottom, top)
  941.  
  942.     create a viewport based on screen normalized values.
  943.  
  944.     subport creates a viewport based upon the passed in screen normalized 
  945.     {left, right, bottom, top} values.  
  946.  
  947.  
  948.   fillrect(float x1, y1, x2, y2)
  949.  
  950.     this uses new polygon drawing routines to draw a filled rectangle.
  951.     This function will work with subpix(TRUE), etc.
  952.  
  953.  
  954.   drawrect(float x1, y1, x2, y2)
  955.  
  956.     uses the new bgn/end -closedline routines to draw a the outline of 
  957.     a rectangle.
  958.  
  959.  
  960.   fillrecti(int x1, y1, x2, y2)
  961.  
  962.     this uses new polygon drawing routines to draw a filled rectangle.
  963.     This function will work with subpix(TRUE), etc.
  964.  
  965.  
  966.   drawrecti(int x1, y1, x2, y2)
  967.  
  968.     uses the new bgn/end -closedline routines to draw a the outline of 
  969.     a rectangle.
  970.  
  971.  
  972.   fillcirc(float x, y, rad)
  973.  
  974.     uses the new bgn/end -polygon routines to draw a filled circle.
  975.  
  976.  
  977.   drawcirc(float x, y, rad)
  978.  
  979.     uses the new bgn/end -closedline routines to draw a circle outline.
  980.  
  981.  
  982.   circsides(int n)
  983.  
  984.     specify the number of line segments for the current circle.
  985.  
  986.  
  987.  
  988.  
  989. =============================================================================
  990. percent.c:  Indicate percent done on time consuming operations.
  991. #include "gl.h"
  992. #include "device.h"
  993.  
  994.   percentdone(float percent)
  995.  
  996.     draw an hourglass cursor showing the percentage of work still to be done.
  997.  
  998.     percentdone takes a floating point number in the range of 0.0..100.0
  999.     and draws an hourglass cursor representative of the percentage of 
  1000.     "time" left until the current task is complete.
  1001.  
  1002.  
  1003.   dosystem(char *name)
  1004.  
  1005.     bracket the system call to be executed by percentdone(0.0) and (100.0).
  1006.  
  1007.  
  1008.  
  1009.  
  1010. =============================================================================
  1011. psimg.c:  Convert image data into b/w or color PostScript.
  1012. #include "image.h"
  1013. #include "math.h"
  1014.  
  1015.   usebinaryps(int b)
  1016.  
  1017.     specify input characters to be read as type string or as hexidecimal digits.
  1018.  
  1019.  
  1020.   frametobwps(FILE *outf;  IMAGE *image)
  1021.  
  1022.     generate a frame of black and white PostScript output to outf from image.
  1023.  
  1024.  
  1025.   frametorgbps(FILE *outf;  IMAGE *image)
  1026.  
  1027.     generate a frame of color PostScript output to outf from image.
  1028.  
  1029.  
  1030.   tobwps(FILE *outf;  int (*getfunc)();  short cortab[256];  
  1031.      int bitsper, xsize, ysize)
  1032.  
  1033.     convert an image into black and white PostScript and store in outf.
  1034.  
  1035.  
  1036.   torgbps(FILE *outf;  int (*getfunc)();  short cortab[256];  
  1037.       int bitsper, xsize, ysize, nproc)
  1038.  
  1039.     convert an image into rgb PostScript and store in outf.
  1040.  
  1041.  
  1042.   tocmykps(FILE *outf;  int (*getfunc)();  short cortab[256];  
  1043.        int bitsper, xsize, ysize, nproc)
  1044.  
  1045.     convert an image into cmyk PostScript and store in outf.
  1046.  
  1047.  
  1048.  
  1049.  
  1050. =============================================================================
  1051. rct.c:  Management of rectangles.
  1052. #include "rct.h"
  1053. #include "port.h"
  1054.  
  1055.   rct *rctnew()
  1056.  
  1057.     allocate memory for a new rct rectangle structure and return its pointer.
  1058.  
  1059.  
  1060.   rctfree(rct *r)
  1061.  
  1062.     de-allocate the memory pointed to by r.
  1063.  
  1064.  
  1065.   rct *rctclone(rct *r)
  1066.  
  1067.     allocate a new rectangle, copy rectangle r into it, and return its pointer.
  1068.  
  1069.  
  1070.   rctcopy(rct *scr, *dst)
  1071.  
  1072.     copy the contents of rectangle src into rectangle dst.
  1073.  
  1074.  
  1075.   rctset(rct *r;  int x1, y1, x2, y2)
  1076.  
  1077.     assign the two x/y corners into rectangle r, and make sure the lessor and
  1078.     greater of each are stored as the min and max values respectively.
  1079.  
  1080.  
  1081.   rctsize(rct *r;  int ox, oy, sizex, sizey)
  1082.  
  1083.     assign the origin (ox,oy) and the origin plus the sizes to the two
  1084.     rectangle corners and then make sure the lessor and greater of each
  1085.     are stored as the min and max values respectively.
  1086.  
  1087.  
  1088.   rctnormal(rct *r)
  1089.  
  1090.     make sure the lessor and greater of each are stored as the min and max 
  1091.     values respectively.
  1092.  
  1093.  
  1094.   rctoffset(rct *r;  int dx, dy)
  1095.  
  1096.     add dx and dy to both x and y parts respectively of rectangle r.
  1097.  
  1098.  
  1099.   rctshrink(rct *r;  int dx, dy)
  1100.  
  1101.     add dx/dy to the x/y min corner and subtract dx/dy to the x/y max 
  1102.     corner value of rectangle r.
  1103.  
  1104.  
  1105.   int rctinter(rct *src1, *src2, *dest)
  1106.  
  1107.     find the min and max of x and y for the two rectangles src1 and src2.
  1108.     if the max of each is greater than or equal to its min, assign these
  1109.     four values to dest;  if not, assign 0 to all four values of dest.
  1110.  
  1111.  
  1112.   rctunion(rct *src1, *src2, *dest)
  1113.  
  1114.     determine the min and max x and y values of rectangles src1 and src2
  1115.     and assign these two the min and max x and y values of dest.
  1116.  
  1117.  
  1118.   rctinside(rct *r;  int x, y)
  1119.  
  1120.     determine if x and y are both inside of rectangle r (or along its edge)
  1121.     and return 1 if they are, else return 0.
  1122.  
  1123.  
  1124.   rctequal(rct *r1, *r2)
  1125.     
  1126.     determine if rectangles r1 and r2 are identical in position.  if so,
  1127.     return 1, else return 0.
  1128.  
  1129.  
  1130.   rctempty(rct *r)
  1131.  
  1132.     determine if either xmin equals xmax or ymin equals ymax.  if so, return
  1133.     1, else return 0.
  1134.  
  1135.  
  1136.   rctdraw(rct *r)
  1137.  
  1138.     draw the rectangle using the new bgn/end -closedline drawing routines.
  1139.  
  1140.  
  1141.   rctfill(rct *r)
  1142.    
  1143.     fills the rectangle using the new bgn/end -polygon drawing routines.
  1144.  
  1145.  
  1146.  
  1147.  
  1148. =============================================================================
  1149. row.c:  Support for operations on image rows.
  1150. #include "image.h"
  1151. #include "lum.h"
  1152.  
  1153.   zerorow(short *sptr;  int n)
  1154.  
  1155.     place n zero bytes in the string pointed to by sptr.
  1156.  
  1157.  
  1158.   copyrow(short *s, *d;  int n)
  1159.  
  1160.     copies n bytes from string s to string d.
  1161.  
  1162.  
  1163.   setrow(short *sptr;  int val, n)
  1164.  
  1165.     assign the n bytes in row sptr the value val.  if n is zero assign
  1166.     zero bytes to all locations in the string.
  1167.  
  1168.  
  1169.   clamprow(short *iptr, *optr;  int n)
  1170.  
  1171.     clamp all values in the iptr row (of length n bytes) of less than zero 
  1172.     at zero and greater than 255 at 255 and store the clamped row in optr.
  1173.  
  1174.  
  1175.   accrow(short *iptr, *sptr;  int w, n)
  1176.  
  1177.     add, subtract or multiply the values in iptr (of length n bytes) by 
  1178.     those in sptr (storing the results in iptr) depending on whether w is 1,
  1179.     -1, or anything else respectively.
  1180.  
  1181.  
  1182.   divrow(short *iptr, *optr;  int tot, n)
  1183.  
  1184.     divide every value in iptr (of length n bytes) by tot and store the 
  1185.     values in optr.
  1186.  
  1187.  
  1188.   rgbrowtobw(unsigned short *rbuf, *gbuf, *bbuf, *obuf;  int n)
  1189.  
  1190.     convert the RGB pixel values (pointed to by rbuf, gbuf and bbuf of 
  1191.     length n bytes) into a single Black and White (8-bit) greyscale value 
  1192.     using the luminance values defined in ../include/lum.h.
  1193.  
  1194.  
  1195.   addsrow(short *dptr, *sptr;  int n)
  1196.  
  1197.     add two short rows together of length n bytes and store their results 
  1198.     in dptr.
  1199.  
  1200.  
  1201.   subsrow(short *dptr, *sptr;  int n)
  1202.  
  1203.     subtract the values in sptr from dptr (of length n bytes) and store 
  1204.     the results in dptr.
  1205.  
  1206.  
  1207.   bitstorow(unsigned char *bits;  short *sbuf;  int n)
  1208.  
  1209.     converts a row of binary one-bit data of length n bits into a row of 
  1210.     short pixel data of either 0 or 255 values.
  1211.  
  1212.  
  1213.   rowtobits(short *sbuf;  unsigned char *bits;  int n)
  1214.  
  1215.     thresholds the row of pixels (of length n bytes) against 128 and 
  1216.     converts this into a one-bit per pixel.  If the pixel value is greater 
  1217.     than 128 it makes it one and if its less than 128 it makes it zero.
  1218.  
  1219.  
  1220.   bitrevbytes(unsigned char *buf;  int n)
  1221.  
  1222.     bit reverse a stream of bytes of length n.
  1223.  
  1224.  
  1225.   flipsrow(short *sptr;  int n)
  1226.  
  1227.     flip a row of shorts.
  1228.  
  1229.  
  1230.   bwtocpack(unsigned short *b;  unsigned long *l;  int n)
  1231.  
  1232.     convert a black and white row of length n bytes into cpack (long) format.
  1233.  
  1234.  
  1235.   rgbtocpack(unsigned short *r, *g, *b;  unsigned long *l;  int n)
  1236.  
  1237.     convert an rgb row of length n bytes into cpack (long) format.
  1238.  
  1239.  
  1240.   rgbatocpack(unsigned short *r, *g, *b, *a;  unsigned long *l;  int n)
  1241.  
  1242.     convert an rgba row of length n bytes into cpack (long) format.
  1243.  
  1244.  
  1245.   cpacktorgb(unsigned long *l;  unsigned short *r, *g, *b;  int n)
  1246.  
  1247.     convert a cpack row of length n bytes into an rgb row format.
  1248.  
  1249.  
  1250.   cpacktorgba(unsigned long *l;  unsigned short *r, *g, *b, *a;  int n)
  1251.  
  1252.     convert a cpack row of length n bytes into an rgba row format.
  1253.  
  1254.  
  1255.   normrow(IMAGE *image;  short *buf)
  1256.  
  1257.     Normalize a row of image data.
  1258.  
  1259.  
  1260.   getbwrow(IMAGE *image;  char *buf;  int y)
  1261.  
  1262.     reads luminance information from either a B&W or RGB file.
  1263.  
  1264.  
  1265.   putfliprow(IMAGE *image;  short *buf;  int y, z, flipcode)
  1266.  
  1267.     putfliprow flips either the X direction or Y direction or both as rows
  1268.     are being written out.
  1269.  
  1270.     01  in the flipcode controls whether rows are mirrored in the X direction.
  1271.     10  in the flipcode controls whether rows are mirrored in the Y direction.
  1272.  
  1273.  
  1274.   getfliprow(IMAGE *image;  short *buf;  int y, z, flipcode)
  1275.  
  1276.     getfliprow flips either the X direction or Y direction or both as rows
  1277.     are being read in.
  1278.  
  1279.     01  in the flipcode controls whether rows are mirrored in the X direction.
  1280.     10  in the flipcode controls whether rows are mirrored in the Y direction.
  1281.  
  1282.  
  1283.  
  1284.  
  1285. =============================================================================
  1286. track.c:  Simple track ball interface.
  1287. #include "gl.h"
  1288. #include "device.h"
  1289. #include "math.h"
  1290. #include "vect.h"
  1291.  
  1292.   trackclick()
  1293.  
  1294.     get and save the current MOUSEX and MOUSEY values.
  1295.     
  1296.  
  1297.   trackpoll()
  1298.  
  1299.     poll and update the state and position of the trackball.
  1300.  
  1301.  
  1302.   tracktransform()
  1303.  
  1304.     transform the trackball by premultiplying the current transformation
  1305.     matrix by the trackball matrix.
  1306.  
  1307.  
  1308.   trackball(float e[4], p1x, p1y, p2x, p2y)
  1309.  
  1310.     simulate a trackball
  1311.  
  1312.     Simulate a track-ball.  Project the points onto the virtual trackball, 
  1313.     then figure out the axis of rotation, which is the cross product of
  1314.     p1 p2 and O p1 (O is the center of the ball, 0,0,0) 
  1315.     Note:  This is a deformed trackball--is a trackball in the center, but 
  1316.     is deformed into a hyperbolic solid of rotation away from the center.
  1317.     It is assumed that the arguments to this routine are in the range
  1318.     (-1.0 ... 1.0).
  1319.  
  1320.  
  1321.   axis_to_quat(vect *a;  float phi, e[4])
  1322.  
  1323.     compute quaternion.
  1324.  
  1325.     using the angle, a, and the axis, phi, compute its quaternion and store
  1326.     the result in array e.
  1327.  
  1328.  
  1329.   float tb_project_to_sphere(float r, x, y) 
  1330.  
  1331.     project onto a sphere or hyperbolic sheet.
  1332.  
  1333.     Project an x, y pair onto a sphere of radius r OR a hyperbolic sheet if 
  1334.     we are away from the center of the sphere.
  1335.  
  1336.  
  1337.   add_quats(float e1[4], e2[4], dest[4])
  1338.  
  1339.     calculate a single rotation from two quaternion rotations.
  1340.  
  1341.     Given two rotations, e1 and e2, expressed as quaternion rotations,
  1342.     compute the equivalent single rotation and save the result into dest.
  1343.     This routine also normalizes the result every RENORMCOUNT times it is
  1344.     called, to keep error from accumulating.
  1345.  
  1346.  
  1347.   normalize_quat(float e[4])
  1348.  
  1349.     renormlize a quaternion.
  1350.  
  1351.     Quaternions always obey:  a^2 + b^2 + c^2 + d^2 = 1.0.  If they don't 
  1352.     add up to 1.0, dividing by their magnitude will renormalize them.
  1353.     Note: See the following for more information on quaternions:
  1354.       - Shoemake, K., Animating rotation with quaternion curves, Computer
  1355.         Graphics 19, No 3 (Proc. SIGGRAPH'85), 245-254, 1985.
  1356.       - Pletinckx, D., Quaternion calculus as a basic tool in computer
  1357.         graphics, The Visual Computer 5, 2-13, 1989.
  1358.  
  1359.  
  1360.   build_rotmatrix(float m[4][4], e[4])
  1361.  
  1362.     Build a rotation matrix, given a quaternion rotation.
  1363.  
  1364.  
  1365.   vcopy3(float *a, *b)
  1366.  
  1367.     copy the 3-element vector a into vector b.
  1368.  
  1369.  
  1370.   myidentity()
  1371.  
  1372.     load the identity matrix onto the top of the transformation matrix stack.
  1373.  
  1374.  
  1375.   matinit()
  1376.  
  1377.     specify MVIEWING mode, load the identity matrix on the stack, and set
  1378.     lsetdepth to be the maximum legal values for the current graphics 
  1379.     hardware.
  1380.  
  1381.  
  1382.  
  1383.  
  1384. =============================================================================
  1385. turtle.c:  A simple implementation of turtle graphics.
  1386. #include "values.h"
  1387. #include "math.h"
  1388. #include "gl.h"
  1389.  
  1390.   CLEARSCREEN()                                            
  1391.  
  1392.     Erase the entire screen area.
  1393.  
  1394.  
  1395.   MOVE(float distance)
  1396.  
  1397.     Move some distance.
  1398.  
  1399.  
  1400.   MOVETO(float x, y)
  1401.  
  1402.     Move to a cartesian coordinate.
  1403.  
  1404.  
  1405.   SPACETO(float x, y, z)
  1406.  
  1407.     Move to a point in 3 space.
  1408.  
  1409.  
  1410.   TURN(float angle)                                              
  1411.  
  1412.     Turn the turtle.
  1413.  
  1414.  
  1415.   TURNTO(float angle)
  1416.  
  1417.     Turn to a specific angle.
  1418.  
  1419.  
  1420.   FILLCOLOR(int fillcolor)
  1421.  
  1422.     Change the fillcolor to be the value of fillcolor.
  1423.  
  1424.  
  1425.   FILLTEXTURE(int filltype)                                  
  1426.  
  1427.     Change the filltexture to be the value of filltexture.
  1428.  
  1429.  
  1430.   PENCOLOR(int threadcolor)
  1431.  
  1432.     Change the pencolor to be the value of threadcolor.
  1433.  
  1434.  
  1435.   PENTYPE(int threadtype)
  1436.  
  1437.     Change the pencolor to be the value of threadtype.
  1438.  
  1439.  
  1440.   WHATCOLOR()                                             
  1441.  
  1442.     Return the current color.
  1443.  
  1444.  
  1445.   WHEREAMI(float *x, *y, *h)
  1446.  
  1447.     Return our current heading and position.
  1448.  
  1449.  
  1450.   BEGINPOLY()
  1451.     
  1452.     Start a polygon.
  1453.  
  1454.  
  1455.   ENDPOLY()
  1456.  
  1457.     Close and fill a polygon.
  1458.  
  1459.  
  1460.   TEXT(float x, y;  char *string)                                   
  1461.  
  1462.     Draw some text at position x,y.
  1463.  
  1464.  
  1465.   VIEWPORT(float x1, y1, x2, y2)
  1466.  
  1467.     Set the viewport.
  1468.  
  1469.  
  1470.   WINDOW(float x1, y1, x2, y2)
  1471.  
  1472.     Set the 2 dimensional orthographic window.
  1473.  
  1474.  
  1475.  
  1476.  
  1477. =============================================================================
  1478. vcolor.c:  Provide virtual rgb and grey scale support.
  1479. #include "gl.h"
  1480. #include "get.h"
  1481. #define NOGREYPATTERNS
  1482. #include "colortbl.inc"
  1483. #include "vect.h"
  1484.  
  1485.   a breakdown of the 2 colormodes we work with here:
  1486.  
  1487.      REALRGB:   this indicates the current displaymode we need to emulate
  1488.                 is either single or double buffered RGB.
  1489.      MAPNEWS:   indicates we're on a 4D IRIS machine where the current
  1490.                 display mode is colormap.
  1491.  
  1492.  
  1493.      
  1494.   rgb(float fr, float fg, float fb)
  1495.  
  1496.     take normalized rgb values, convert them to integers in the range 0..255
  1497.     and then set this color value to be the current color.
  1498.  
  1499.  
  1500.   rgbi(int r, int g, int b)
  1501.  
  1502.     take an rgb triplet and set this to be the current color no matter what
  1503.     the current display mode happens to be.  then return either the color
  1504.     lookup table index or the 24 bits of rgb information into an integer.
  1505.  
  1506.  
  1507.   hsv(float h, float s, float v)
  1508.  
  1509.     convert hue, saturation, value floating point values to normalized rgb 
  1510.     floating point values, set this color to be the current color, and 
  1511.     return this value either as a color lookup table index or as a 24 bits
  1512.     worth of rgb information as an integer.
  1513.  
  1514.  
  1515.   hsvi(int h, int s, int v)
  1516.  
  1517.     convert hue, saturation, value integer values to normalized rgb floating 
  1518.     point values, set this color to be the current color, and return this 
  1519.     value either as a color lookup table index or as a 24 bits worth of rgb 
  1520.     information as an integer.
  1521.  
  1522.  
  1523.   grey(fg)
  1524.  
  1525.     takes a normalized floating point value representing a grey value and
  1526.     defines this as the current color regardless of what the current
  1527.     display mode is, and then returns this value either as a color lookup 
  1528.     table index or as a 24 bits worth of rgb information as an integer.
  1529.  
  1530.  
  1531.   greyi(g)
  1532.  
  1533.     takes an integer value in the range of 0..255 representing a grey value 
  1534.     and defines this as the current color regardless of what the current
  1535.     display mode is, and then returns this value either as a color lookup 
  1536.     table index or as a 24 bits worth of rgb information as an integer.
  1537.  
  1538.  
  1539.   pseudorgb()
  1540.  
  1541.     define the current color mode to either be the kind of colormap used 
  1542.     with 8-bit systems which implements a swank dithering algorithm to 
  1543.     better simulate RGB resolution, in this case "MAPNEWS", or true RGBmode 
  1544.     is possible and the current color mode value is set to "REALRGB."
  1545.  
  1546.  
  1547.   colorinit()
  1548.  
  1549.     initialize the current colormode based on the current displaymode.
  1550.  
  1551.  
  1552.  
  1553.  
  1554. =============================================================================
  1555. vect.c:  Various functions to support operations on vectors.
  1556. #include "vect.h"
  1557.  
  1558.   vect *vnew()
  1559.  
  1560.     allocate a new vector and return its pointer.   
  1561.  
  1562.  
  1563.   vect *vclone(vect *v)
  1564.  
  1565.     allocate a new vector, copy vector v into it, and return its pointer.
  1566.  
  1567.  
  1568.   vcopy(vect *v1, *v2)
  1569.  
  1570.     copy the contents of v1 into v2.
  1571.  
  1572.  
  1573.   vprint(vect *v)
  1574.  
  1575.     print the x/y/z values of vector v to stdout.
  1576.  
  1577.  
  1578.   vprint4(vect *v)
  1579.  
  1580.     print the x/y/z/w values of vector v to stdout.
  1581.  
  1582.  
  1583.   vset(vect *v;  float x, y, z)
  1584.  
  1585.     assign the vector (x, y, z) to v.
  1586.  
  1587.  
  1588.   vzero(vect *v)
  1589.  
  1590.     assign the four components (x, y, z, w) of vector v to be 0.0.
  1591.  
  1592.  
  1593.   vone(vect *v)
  1594.  
  1595.     assign the four components (x, y, z, w) of vector v to be 1.0.
  1596.  
  1597.  
  1598.   vset4(vect *v;  float x, y, z, w)
  1599.  
  1600.     assign the values (x, y, z, y) to the vector v.
  1601.  
  1602.  
  1603.   vnormal(vect *v)
  1604.  
  1605.     normalize the vector v to be of unit length.
  1606.  
  1607.  
  1608.   float vlength(vect *v)
  1609.  
  1610.     compute and then return the length, or norm, of vector v.
  1611.  
  1612.  
  1613.   vscale(vect *v;  float mul)
  1614.  
  1615.     scale the (x,y,z) components of vector by a factor of mul.
  1616.  
  1617.  
  1618.   vmult(vect *src1, *src2, *dst)
  1619.  
  1620.     multiply the individual components of vectors src1 and src2 and save
  1621.     their results into dst.
  1622.  
  1623.  
  1624.   vadd(vect *src1, *src2, *dst)
  1625.  
  1626.     add the individual components of vectors src1 and src2 and save their 
  1627.     results into dst.
  1628.  
  1629.  
  1630.   vsub(vect *src1, *src2, *dst)
  1631.  
  1632.     subtract the individual components of vectors src1 and src2 and save 
  1633.     their results into dst.
  1634.  
  1635.  
  1636.   vhalf(vect *v1, *v2, *half)
  1637.  
  1638.     takes 2 vectors and gives back a vector halfway in between these 2.
  1639.  
  1640.  
  1641.   float vdot(vect *v1, *v2)
  1642.  
  1643.     compute and return the cosine of the angle, or dot product, between 
  1644.     vectors v1 and v2.
  1645.  
  1646.  
  1647.   vcross(vect *v1, *v2, *cross)
  1648.  
  1649.     using the cross product, compute the vector that is perpendicular to v1 
  1650.     and v2 and save it into cross.
  1651.  
  1652.  
  1653.   vplane(vect *normal, *point, *plane)
  1654.  
  1655.     generate the coefficients for the plane that is perpendicular to the
  1656.     vector normal and passes through the vector point.  save the resulting
  1657.     coefficients in plane.
  1658.  
  1659.  
  1660.   vdirection(vect *v1, *dir)
  1661.  
  1662.     generate the normal vector of v1 and save it into dir.
  1663.  
  1664.  
  1665.   makeplane(vect *p1, *p2, *p3, *v)
  1666.  
  1667.     return a plane equation in the vector v for the 3 vertices p1, p2, & p3.
  1668.  
  1669.  
  1670.   vreflect(vect *in, *mirror, *out)
  1671.  
  1672.     create a vector in out that is the result of mirroring the in vector with 
  1673.     the mirror vector.
  1674.  
  1675.  
  1676.   vmultmatrix(float m1[4][4], m2[4][4], prod[4][4])
  1677.  
  1678.     multiply the row/column values of matrices m1 and m2 and save the 
  1679.     resulting matrix into prod.
  1680.  
  1681.  
  1682.   vtransform(vect *v;  float mat[4][4];  vect *vt)
  1683.  
  1684.     transform vector v by matrix mat and save the result in vector vt.
  1685.  
  1686.  
  1687.   vlerp(vect *v0, *v1, *v;  float p)
  1688.  
  1689.     using the parameter p, linearly interpolate the respective components of 
  1690.     vectors v0 and v1, and store the results in vector v.
  1691.     
  1692.   float flerp(float f0, f1, p)
  1693.  
  1694.     using the parameter p, linearly interpolate between 2 floating point 
  1695.     values f0 and f1.  if p equals 0.0, f0 is returned.  if p equals 1.0,
  1696.     f1 is returned.  if p equals 0.5, the average of f0 and f1 is returned.
  1697.  
  1698.  
  1699.   lerp(int i0, i1;  float p)
  1700.  
  1701.     integer version of flerp--using the floating point parameter p, linearly
  1702.     interpolate between the two integer values i0 and i1.
  1703.  
  1704.  
  1705.   int trinormal(vect *p00, *p01, *p10, *n;  float tol)
  1706.  
  1707.     takes the 3 verticies, p00, p01, and p02, and returns the normal of that 
  1708.     triangle.
  1709.  
  1710.  
  1711.